#include "config/type.h"
#include "config/sys_param.h"
#include "lib/stdio.h"
#include "lib/string.h"
#include "sched/proc.h"
#include "sys/syscall.h"

// 系统调用
extern uint64 sys_chdir(void);
extern uint64 sys_close(void);
extern uint64 sys_dup(void);
extern uint64 sys_exec(void);
extern uint64 sys_exit(void);
extern uint64 sys_fork(void);
extern uint64 sys_fstat(void);
extern uint64 sys_getpid(void);
extern uint64 sys_kill(void);
extern uint64 sys_link(void);
extern uint64 sys_mkdir(void);
extern uint64 sys_mknod(void);
extern uint64 sys_open(void);
extern uint64 sys_pipe(void);
extern uint64 sys_read(void);
extern uint64 sys_sbrk(void);
extern uint64 sys_sleep(void);
extern uint64 sys_unlink(void);
extern uint64 sys_wait(void);
extern uint64 sys_write(void);
extern uint64 sys_uptime(void);

// 从当前进程中获取addr处的uint64参数。
int fetchaddr(uint64 addr, uint64 *ip) {
	struct proc *p = myproc();
	if (addr >= p->sz || addr + sizeof(uint64) > p->sz)
		return -1;
	if (copyin(p->pagetable, (char *)ip, addr, sizeof(*ip)) != 0)
		return -1;
	return 0;
}

// 从当前进程中获取addr处以nul结尾的字符串。
// 返回字符串的长度，不包括nul，或者-1表示错误。
int fetchstr(uint64 addr, char *buf, int max) {
	struct proc *p = myproc();
	int err = copyinstr(p->pagetable, buf, addr, max);
	if (err < 0)
		return err;
	return strlen(buf);
}

// TODO: 需要针对龙芯架构做改造
static uint64 argraw(int n) 
{
	struct proc *p = myproc();
	switch (n) {
	case 0:
		return p->trapframe->a0;
	case 1:
		return p->trapframe->a1;
	case 2:
		return p->trapframe->a2;
	case 3:
		return p->trapframe->a3;
	case 4:
		return p->trapframe->a4;
	case 5:
		return p->trapframe->a5;
	case 6:
		return p->trapframe->a6;
	case 7:
		return p->trapframe->a7;
	}
	panic(syscall, "failed to find system call argv[%d]", n);
	return -1;
}

// 获取第n个系统调用 int32 参数。
int argint(int n, int *ip) {
	*ip = argraw(n);
	return 0;
}

// 获取第n个作为指针的参数。
// 不负责检查合法性，因为 copyin/copyout会负责。
int argaddr(int n, uint64 *ip) {
	*ip = argraw(n);
	return 0;
}

// 获取长度为max的，null结尾的字符串，作为系统调用参数。
// 复制到buf中，最多可复制长度max。
// 正常运行（包括nul）则返回字符串长度，如果错误则返回-1。
int argstr(int n, char *buf, int max) {
	uint64 addr;
	if (argaddr(n, &addr) < 0)
		return -1;
	return fetchstr(addr, buf, max);
}

static uint64 (*syscalls[])(void) = {
	[SYS_fork] sys_fork,   [SYS_exit] sys_exit,     [SYS_wait] sys_wait,
	[SYS_pipe] sys_pipe,   [SYS_read] sys_read,     [SYS_kill] sys_kill,
	[SYS_exec] sys_exec,   [SYS_fstat] sys_fstat,   [SYS_chdir] sys_chdir,
	[SYS_dup] sys_dup,     [SYS_getpid] sys_getpid, [SYS_sbrk] sys_sbrk,
	[SYS_sleep] sys_sleep, [SYS_uptime] sys_uptime, [SYS_open] sys_open,
	[SYS_write] sys_write, [SYS_mknod] sys_mknod,   [SYS_unlink] sys_unlink,
	[SYS_link] sys_link,   [SYS_mkdir] sys_mkdir,   [SYS_close] sys_close,
};

// TODO: 要思考此处 syscall() 接受谁传参数？给谁传参数？
// xv6-riscv 逻辑：系统调用号在 a7，调用前参数放进 p->trapframe->a0-a5
// loongarch 的传参寄存器：a0, a2-a7

// 系统调用入口
void syscall(void) {
	// 中断号
	int num;
	// 呼叫系统调用的当前进程
	struct proc *p = myproc();
	num = p->trapframe->a7;	
	if (num > 0 && num < NELEM(syscalls) && syscalls[num]) {
		p->trapframe->a0 = syscalls[num]();
	} else {
		pr_error(syscall, "process[%d] %s: unknown syscall %d", p->pid, p->name, num);
		p->trapframe->a0 = -1;
	}
}